import java.util.Scanner;

public class Test {
    /*public static void main(String[] args) {
        //是否为素数
        for (int i = 2; i <= 100 ; i++) {
            boolean isTrue = true;
            for (int j = 2; j < i ; j++) {
                if(i % j == 0){
                    isTrue = false;
                    break;
                }

            }
            if(isTrue == true){
                System.out.println(i + " ");
            }
        }
    }*/
    /*public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入年份");
        int year = scanner.nextInt();
        if(year % 4 == 0 && year % 100 != 0 || year % 400 == 0){
            System.out.println("是闰年");
        }

    }*/

    public static void main(String[] args) {

    }



}
 /*class Example {
    public static int count = 0; // 静态变量

    public Example() {
        count++; // 每次创建对象时，count的值加1
    }

    public static void main(String[] args) {
        Example obj1 = new Example();
        Example obj2 = new Example();

        System.out.println(Example.count); // 输出2
    }
}*/

 /*class Example {
    private static int value = 10; // 静态变量

    public static int getValue() { // 静态方法
        return value;
    }

    public static void main(String[] args) {
        int result = Example.getValue(); // 直接通过类名调用静态方法
        System.out.println(result); // 输出10
    }
}*/
/*  class ParameterPassingDemo {
     public static void main(String[] args) {
         // 基本数据类型参数传递
         int num = 10;
         System.out.println("基本类型传递前: num = " + num); // 输出10
         modifyPrimitive(num);
         System.out.println("基本类型传递后: num = " + num); // 仍输出10，值未改变

         // 引用数据类型参数传递
         Person person = new Person("Alice");
         System.out.println("引用类型传递前: name = " + person.getName()); // 输出Alice
         modifyReference(person);
         System.out.println("引用类型传递后: name = " + person.getName()); // 输出Bob，对象被修改

         // 尝试修改引用指向
         resetReference(person);
         System.out.println("尝试重置引用后: name = " + person.getName()); // 仍输出Bob，引用未被重置
     }

     // 修改基本数据类型参数
     public static void modifyPrimitive(int value) {
         value = 20; // 修改的是副本，不影响原始值
     }

     // 修改引用数据类型参数
     public static void modifyReference(Person p) {
         p.setName("Bob"); // 通过引用副本修改对象内容
     }

     // 尝试重置引用数据类型参数
     public static void resetReference(Person p) {
         p = new Person("Charlie"); // 修改的是引用副本的指向，不影响原始引用
     }
 }*/

/*class Person {
    private String name;
    public Person(String name) { this.name = name; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
}*/


 /*class Example {
    public int add(int a, int b) { return a + b; }           // 两个int
    public int add(int a, int b, int c) { return a + b + c; } // 三个int
    public double add(double a, double b) { return a + b; }  // 两个double
    public double add(int a, double b) { return a + b; }     // int+double
    public double add(double a, int b) { return a + b; }     // double+int（顺序不同）
}*/

 /*class Example {
    // 实例变量 - 每个对象都有自己的副本
    private int instanceVar;

    // 静态变量 - 所有对象共享同一个副本
    private static int staticVar;

    public Example(int instanceVar) {
        this.instanceVar = instanceVar;
        staticVar++; // 每次创建对象时递增静态变量
    }

    public void printVars() {
        System.out.println("实例变量: " + instanceVar);
        System.out.println("静态变量: " + staticVar);
    }

    public static void main(String[] args) {
        Example obj1 = new Example(10);
        Example obj2 = new Example(20);

        obj1.printVars(); // 输出: 实例变量: 10，静态变量: 2
        obj2.printVars(); // 输出: 实例变量: 20，静态变量: 2
    }
}*/

/* class Example {
    // 实例变量
    private int instanceVar;

    // 静态变量
    private static int staticVar;

    public Example(int instanceVar) {
        this.instanceVar = instanceVar;
        staticVar++;
    }

    // 实例方法 - 可以访问实例变量和静态变量
    public void instanceMethod() {
        System.out.println("实例方法访问:");
        System.out.println("  实例变量: " + instanceVar);
        System.out.println("  静态变量: " + staticVar);
    }

    // 静态方法 - 只能直接访问静态变量
    public static void staticMethod() {
        System.out.println("静态方法访问:");
        // System.out.println(instanceVar); // 错误！静态方法不能直接访问实例变量
        System.out.println("  静态变量: " + staticVar);
    }

    public static void main(String[] args) {
        Example obj = new Example(10);

        // 调用实例方法（需通过对象）
        obj.instanceMethod();

        // 调用静态方法（通过类名，也可通过对象但不推荐）
        Example.staticMethod();
        // obj.staticMethod(); // 不推荐这种写法，容易混淆静态方法的归属
    }
}*/

 /*class Person {
    // 私有属性（外部无法直接访问）
    private String name;
    private int age;

    // Getter 方法：返回属性值
    public String getName() {
        return this.name;
    }

    // Setter 方法：修改属性值（可添加逻辑校验）
    public void setName(String name) {
        this.name = name;
    }

    // Getter 方法
    public int getAge() {
        return this.age;
    }

    // Setter 方法（添加年龄校验逻辑）
    public void setAge(int age) {
        if (age < 0 || age > 150) {
            throw new IllegalArgumentException("年龄必须在 0-150 之间");
        }
        this.age = age;
    }
}*/


 /*class Book {
    // 私有属性
    private String title;
    private String author;
    private double price;
    // 1. 无参构造方法
    public Book() {
        title = "未命名";
        author = "未知";
        price = 0.0;
    }

    // 3. 带参构造方法（全部参数）
    public Book(String title, String author, double price) {
        this.title = title;
        this.author = author;
        this.price = price;
    }

    // Getter 方法
    public String getTitle() {
        return title;
    }

    public String getAuthor() {
        return author;
    }

    public double getPrice() {
        return price;
    }

    // 普通方法：打印书籍信息
    public void displayInfo() {
        System.out.printf("《%s》由%s著，价格：%.2f元%n", title, author, price);
    }

    public static void main(String[] args) {
        // 使用不同构造方法创建对象
        Book book1 = new Book();
        book1.displayInfo(); // 输出：《未命名》由未知著，价格：0.00元

        Book book3 = new Book("Effective Java", "Joshua Bloch", 99.0);
        book3.displayInfo(); // 输出：《Effective Java》由Joshua Bloch著，价格：99.00元
    }
}
*/



